home *** CD-ROM | disk | FTP | other *** search
/ Technotools / Technotools (Chestnut CD-ROM)(1993).ISO / misc_pto / beav132s / random.c < prev    next >
C/C++ Source or Header  |  1991-11-07  |  30KB  |  1,358 lines
  1. /*
  2. *              Assorted commands.
  3. * The file contains the command
  4. * processors for a large assortment of unrelated
  5. * commands. The only thing they have in common is
  6. * that they are all command processors.
  7. */
  8.  
  9. #include    "def.h"
  10.  
  11. char    backdel ();
  12. bool    fill_out ();
  13. void    bad_key ();
  14.  
  15.  
  16.  
  17. extern    char    MSG_sh_pos[];
  18. extern    char    MSG_sh_pos1[];
  19. extern    char    MSG_f_str[];
  20. extern    char    MSG_3u[];
  21. extern    char    MSG_5u[];
  22. extern    char    MSG_lu[];
  23. extern    char    MSG_03u[];
  24. extern    char    MSG_05u[];
  25. extern    char    MSG_010lu[];
  26. extern    char    MSG_lnk[];
  27. extern    char    MSG_unlink[];
  28. extern    char    MSG_link[];
  29. extern    char    MSG_bad_key[];
  30. extern    char    MSG_esc[];
  31. extern    char    MSG_ctl_x[];
  32. extern    char    MSG_ctl[];
  33. extern    char    MSG_key_code[];
  34. extern    char    char_str[];
  35. extern    char    MSG_w_not_empty[];
  36. extern    char    MSG_procing[];
  37. extern    char    MSG_ok[];
  38. #if RUNCHK
  39. extern    char    ERR_rnd_1[];
  40. extern    char    ERR_rnd_2[];
  41. extern    char    ERR_rnd_3[];
  42. extern    char    ERR_rnd_4[];
  43. extern    char    ERR_rnd_5[];
  44. extern    char    ERR_rnd_6[];
  45. extern    char    ERR_rnd_7[];
  46. #endif
  47.  
  48. extern  ROW_FMT ascii_fmt;
  49. extern  ROW_FMT ebcdic_fmt;
  50. extern  ROW_FMT binary_8_fmt;
  51. extern  ROW_FMT binary_16_fmt;
  52. extern  ROW_FMT binary_32_fmt;
  53. extern  ROW_FMT octal_8_fmt;
  54. extern  ROW_FMT octal_16_fmt;
  55. extern  ROW_FMT octal_32_fmt;
  56. extern  ROW_FMT decimal_8_fmt;
  57. extern  ROW_FMT decimal_16_fmt;
  58. extern  ROW_FMT decimal_32_fmt;
  59. extern  ROW_FMT hex_8_fmt;
  60. extern  ROW_FMT hex_16_fmt;
  61. extern  ROW_FMT hex_32_fmt;
  62.  
  63. extern  bool    read_pat_mode;
  64. extern  bool    dont_repeat;
  65. extern    BUFFER  sav_buf;
  66.  
  67. char    dec_chr_ok ();
  68. ulong   get_long ();
  69. void wind_on_dot_all ();
  70.  
  71. /*
  72. * Display a bunch of useful information about
  73. * the current location of dot and mark.
  74. * The position of the dot and mark and the difference between them.
  75. * The total buffer size is displayed.
  76. * This is normally bound to "C-X =".
  77. */
  78. bool showcpos (f, n, k)
  79. {
  80.  
  81.     A32     dotoff,
  82.         markoff,
  83.         fsize,
  84.         bsize;
  85.     char    buf[NCOL * 2], buf1[NCOL * 2];
  86.  
  87.     dotoff = curwp -> w_dotp -> l_file_offset;
  88.     dotoff += curwp -> w_doto;
  89.  
  90.     if (curwp -> w_markp != NULL)
  91.     {
  92.         markoff = curwp -> w_markp -> l_file_offset;
  93.         markoff += curwp -> w_marko;
  94.     }
  95.  
  96.     bsize = curwp -> w_bufp -> b_linep -> l_bp -> l_file_offset;
  97.     bsize += curwp -> w_bufp -> b_linep -> l_bp -> l_used;
  98.     fsize = curbp -> b_file_size;
  99.  
  100.     if (curwp -> w_markp != NULL)
  101.     {
  102.         /* build format string */
  103.         sprintf (buf1, MSG_sh_pos, R_POS_FMT(curwp), R_POS_FMT(curwp), 
  104.             R_POS_FMT(curwp), R_POS_FMT(curwp));
  105.         sprintf (buf, buf1, dotoff, markoff, bsize, fsize);
  106.     }
  107.     else
  108.     {
  109.         /* build format string */
  110.         sprintf (buf1, MSG_sh_pos1, R_POS_FMT(curwp), R_POS_FMT(curwp), 
  111.             R_POS_FMT(curwp));
  112.         sprintf (buf, buf1, dotoff, bsize, fsize);
  113.     }
  114.  
  115.     sprintf (&buf[strlen(buf)], MSG_f_str, curbp -> b_fname);
  116.     writ_echo (buf);
  117.  
  118.     return (TRUE);
  119. }
  120.  
  121.  
  122. /*
  123. * Twiddle the two characters on either side of
  124. * dot. If dot is at the end of the line twiddle the
  125. * two characters before it. Return with an error if dot
  126. * is at the beginning of line; it seems to be a bit
  127. * pointless to make this work. This fixes up a very
  128. * common typo with a single stroke. Normally bound
  129. * to "C-T". This always works within a line, so
  130. * "WFEDIT" is good enough.
  131. */
  132. bool twiddle ()
  133. {
  134.  
  135.     register    LINE * dotp;
  136.     register short  doto;
  137.     char    b_per_u,
  138.     f_buf[4],
  139.     s_buf[4],
  140.     i;
  141.  
  142.     dotp = curwp -> w_dotp;
  143.     doto = curwp -> w_doto;
  144.     b_per_u = curwp -> w_fmt_ptr -> r_b_per_u;
  145.     /* try to move back one unit */
  146.     if (!move_ptr (curwp, (long) - b_per_u, TRUE, TRUE, TRUE))
  147.     {
  148.         curwp -> w_dotp = dotp; /* if fail then restore dot and quit */
  149.         curwp -> w_doto = doto;
  150.         ttbeep ();
  151.         return (FALSE);
  152.     }
  153.     /* pick up first unit byte by byte */
  154.     for (i = 0; i < b_per_u; i++)
  155.     {
  156.         f_buf[i] = DOT_CHAR(curwp);
  157.         move_ptr (curwp, 1L, TRUE, FALSE, TRUE);
  158.     }
  159.     /* move to the end of the second unit */
  160.     if (!move_ptr (curwp, (long) (b_per_u - 1), TRUE, FALSE, TRUE))
  161.     {
  162.         curwp -> w_dotp = dotp; /* if fail then restore dot and quit */
  163.         curwp -> w_doto = doto;
  164.         ttbeep ();
  165.         return (FALSE);
  166.     }
  167.     /* pick up second unit (reverse order) and deposit second unit */
  168.     for (i = 0; i < b_per_u; i++)
  169.     {
  170.         s_buf[i] = DOT_CHAR(curwp);
  171.         DOT_CHAR(curwp) = f_buf[b_per_u - 1 - i];
  172.         move_ptr (curwp, -1L, TRUE, FALSE, TRUE);
  173.     }
  174.     /* deposit first unit */
  175.     for (i = 0; i < b_per_u; i++)
  176.     {
  177.         DOT_CHAR(curwp) = s_buf[i];
  178.         move_ptr (curwp, -1L, TRUE, FALSE, TRUE);
  179.     }
  180.     curwp -> w_dotp = dotp;
  181.     curwp -> w_doto = doto;
  182.     lchange (WFHARD);
  183.     return (TRUE);
  184. }
  185.  
  186. /*
  187. * Quote the next character, and
  188. * insert it into the buffer. All the characters
  189. * are taken literally.
  190. * The character
  191. * is always read, even if it is inserted 0 times, for
  192. * regularity.
  193. */
  194. bool quote (f, n, k)
  195. {
  196.     register int    c;
  197.  
  198.     if (kbdmop != NULL)
  199.         c = *kbdmop++;
  200.     else
  201.     {
  202.         c = ttgetc ();
  203.         if (kbdmip != NULL)
  204.         {
  205.             if (kbdmip > &kbdm[NKBDM - 4])
  206.             {
  207.                 ctrlg (FALSE, 0, KRANDOM);
  208.                 return (ABORT);
  209.             }
  210.  
  211.             *kbdmip++ = c;
  212.         }
  213.  
  214.     }
  215.  
  216.     if (n < 0)
  217.         return (FALSE);
  218.     if (n == 0)
  219.         return (TRUE);
  220.  
  221.     return (linsert (n, c));
  222. }
  223.  
  224. /*
  225. * Toggle the insert mode.  Insert mode is used only in ASCII or EBCDIC modes.
  226. */
  227. bool insert_toggle ()    /* toggle routine for selfinsert */
  228. {
  229.     register    WINDOW * wp;
  230.  
  231.     if (curbp -> b_flag & BFSLOCK)
  232.         return (TRUE);
  233.  
  234.     if (read_pat_mode)
  235.         dont_repeat = TRUE;
  236.  
  237.     insert_mode = !insert_mode;
  238.     for (wp = wheadp; wp; wp = wp -> w_wndp)
  239.         wp -> w_flag |= WFMODE; /* force mode line update */
  240.     return (TRUE);
  241. }
  242.  
  243. /*
  244. * Ordinary text characters are bound to this function,
  245. * which inserts them into the buffer. Characters marked as control
  246. * characters (using the CTRL flag) may be remapped to their ASCII
  247. * equivalent. This makes TAB (C-I) work right, and also makes the
  248. * world look reasonable if a control character is bound to this
  249. * this routine by hand. Any META or CTLX flags on the character
  250. * are discarded. 
  251. * 
  252. *   Edit the unit under the cursor.
  253. *   Check that the character is valid for the current display mode.
  254. */
  255.  
  256. bool selfinsert (f, n, k)
  257. {
  258.  
  259.     register int    c;
  260.     char    edt_buf[4],
  261.     i_chr,
  262.     b_per_u,
  263.     u_offs,
  264.     u_roffs,
  265.     bit_shf,
  266.     i;
  267.     LINE    * l_ptr;
  268.     short   d_offs;
  269.     int     bytes,
  270.     temp_int;
  271.     long    dot_shf,
  272.     l_mask,
  273.     l_val;
  274.     char    text_buf[12];
  275.     static char max_dec_8[] = "255";
  276.     static char max_dec_16[] = "65535";
  277.     static char max_dec_32[] = "4294967295";
  278.     int        cur_col;
  279.  
  280.     bool intel;
  281.  
  282.     if (n < 0)
  283.     {
  284.         ttbeep ();
  285.         return (FALSE);
  286.     }
  287.     if (n == 0)
  288.     {
  289.         ttbeep ();
  290.         return (TRUE);
  291.     }
  292.     c = k & KCHAR;
  293.     if ((k & KCTRL) != 0 && c >= '@' && c <= '_')/* ASCII-ify.           */
  294.         c -= '@';
  295.     b_per_u = curwp -> w_fmt_ptr -> r_b_per_u;
  296.     u_offs = curwp -> w_unit_offset;
  297.     u_roffs = curwp -> w_fmt_ptr -> r_chr_per_u - u_offs - 1;
  298.     intel = curwp -> w_intel_mode;
  299.  
  300.     cur_col = ttcol;
  301.  
  302.     switch (curwp -> w_fmt_ptr -> r_type)
  303.     {
  304.     case EBCDIC:
  305.         c = to_ebcdic (c);  /* convert ASCII to EBCDIC */
  306.     case ASCII:
  307.         if ((insert_mode) || (DOT_POS(curwp) == BUF_SIZE(curwp)))
  308.         {
  309.             linsert (n, c);
  310.             if (read_pat_mode)
  311.                 forwchar (0, 1, KRANDOM);/* advance the cursor */
  312.         }
  313.         else
  314.             lreplace (n, c);
  315.         break;
  316.  
  317.     case HEX:
  318.         if ((c >= '0') && (c <= '9'))
  319.         {
  320.             i_chr = c - '0';/* convert to binary */
  321.         }
  322.         else
  323.             if ((c >= 'A') && (c <= 'F'))
  324.             {
  325.                 i_chr = c - 'A' + 10;/* convert to binary */
  326.             }
  327.             else
  328.                 if ((c >= 'a') && (c <= 'f'))
  329.                 {
  330.                     i_chr = c - 'a' + 10;/* convert to binary */
  331.                 }
  332.                 else
  333.                 {
  334.                     bad_key (k);
  335.                     return (FALSE);
  336.                 }
  337.         fill_out (); /* expand buffer if necessary */
  338.  
  339.         /* position dot to byte to be altered */
  340.         if (intel)
  341.             dot_shf = u_roffs >> 1;
  342.         else
  343.             dot_shf = u_offs >> 1;
  344.  
  345.         /* save dot position for later */
  346.         l_ptr = curwp -> w_dotp;
  347.         d_offs = curwp -> w_doto;
  348.         move_ptr (curwp, dot_shf, TRUE, FALSE, TRUE);
  349.  
  350.         if (u_offs & 1)
  351.         {               /* lower nibble in byte */
  352.             i_chr &= 0x0f;
  353.             DOT_CHAR(curwp) &= 0xf0;
  354.             DOT_CHAR(curwp) |= i_chr;
  355.         }
  356.         else
  357.         {               /* upper nibble in byte */
  358.             i_chr <<= 4;
  359.             i_chr &= 0xf0;
  360.             DOT_CHAR(curwp) &= 0x0f;
  361.             DOT_CHAR(curwp) |= i_chr;
  362.         }
  363.  
  364.         /* restore dot position */
  365.         curwp -> w_dotp = l_ptr;
  366.         curwp -> w_doto = d_offs;
  367.         forwchar (0, 1, KRANDOM);/* advance the cursor */
  368.         break;
  369.  
  370.     case BINARY:
  371.         if ((c != '0') && (c != '1'))
  372.         {
  373.             bad_key (k);
  374.             return (FALSE);
  375.         }
  376.  
  377.         /* position dot to byte to be altered */
  378.         if (intel)
  379.             dot_shf = u_roffs >> 3;
  380.         else
  381.             dot_shf = u_offs >> 3;
  382.  
  383.         fill_out (); /* expand buffer if necessary */
  384.  
  385.         /* save dot position for later */
  386.         l_ptr = curwp -> w_dotp;
  387.         d_offs = curwp -> w_doto;
  388.         move_ptr (curwp, dot_shf, TRUE, FALSE, TRUE);
  389.  
  390.         bit_shf = u_roffs & 0x07;
  391.  
  392.         if (c == '0')
  393.         {
  394.             DOT_CHAR(curwp) &= ~(1 << bit_shf);
  395.         }
  396.         else
  397.         {
  398.             DOT_CHAR(curwp) |= 1 << bit_shf;
  399.         }
  400.  
  401.         /* restore dot position */
  402.         curwp -> w_dotp = l_ptr;
  403.         curwp -> w_doto = d_offs;
  404.         forwchar (0, 1, KRANDOM);/* advance the cursor */
  405.         break;
  406.  
  407.     case OCTAL:
  408.         if (c < '0')
  409.         {
  410.             bad_key (k);
  411.             return (FALSE);
  412.         }
  413.         else
  414.             if ((c > '1') && (u_offs == 0) &&
  415.                 ((curwp -> w_fmt_ptr -> r_size) == WORDS))
  416.             {
  417.                 bad_key (k);
  418.                 return (FALSE);
  419.             }
  420.             else
  421.                 if ((c > '3') && (u_offs == 0))
  422.                 {
  423.                     bad_key (k);
  424.                     return (FALSE);
  425.                 }
  426.                 else
  427.                     if (c > '7')
  428.                     {
  429.                         bad_key (k);
  430.                         return (FALSE);
  431.                     }
  432.  
  433.         dot_shf = (c - '0') & 7;/* get binary value */
  434.         l_mask = 7;         /* create bit mask */
  435.  
  436.         dot_shf <<= (u_roffs * 3);
  437.         l_mask <<= (u_roffs * 3);
  438.  
  439.         fill_out (); /* expand buffer if necessary */
  440.  
  441.         /* save dot position for later */
  442.         l_ptr = curwp -> w_dotp;
  443.         d_offs = curwp -> w_doto;
  444.  
  445.         /* position dot to the byte to be altered */
  446.         if (intel)
  447.         {
  448.             for (i = 0; i < b_per_u; i++)
  449.             {
  450.                 DOT_CHAR(curwp) &= ~((D8) l_mask & 0xff);
  451.                 DOT_CHAR(curwp) |= (D8) dot_shf & 0xff;
  452.                 l_mask >>= 8;
  453.                 dot_shf >>= 8;
  454.                 move_ptr (curwp, 1L, TRUE, FALSE, TRUE);
  455.             }
  456.         }
  457.         else
  458.         {
  459.             move_ptr (curwp, (long) (b_per_u - 1), TRUE, FALSE, TRUE);
  460.             /* move to last byte */
  461.             for (i = 0; i < b_per_u; i++)
  462.             {
  463.                 DOT_CHAR(curwp) &= ~((D8) l_mask & 0xff);
  464.                 DOT_CHAR(curwp) |= (D8) dot_shf & 0xff;
  465.                 l_mask >>= 8;
  466.                 dot_shf >>= 8;
  467.                 move_ptr (curwp, -1L, TRUE, FALSE, TRUE);/* step back one byte */
  468.             }
  469.         }
  470.  
  471.         /* restore dot position */
  472.         curwp -> w_dotp = l_ptr;
  473.         curwp -> w_doto = d_offs;
  474.         forwchar (0, 1, KRANDOM);/* advance the cursor */
  475.         break;
  476.  
  477.     case DECIMAL:
  478.         fill_out (); /* expand buffer if necessary */
  479.  
  480.         /* save dot position for later */
  481.         l_ptr = curwp -> w_dotp;
  482.         d_offs = curwp -> w_doto;
  483.  
  484.         bytes = fill_buf (curwp, l_ptr, d_offs, edt_buf, b_per_u);
  485.         /* if last unit is not full and must be extended */
  486.         for (; bytes < b_per_u; bytes++)
  487.         {
  488.             edt_buf[3] = edt_buf[2];/* shuffle bytes down */
  489.             edt_buf[2] = edt_buf[1];
  490.             edt_buf[1] = edt_buf[0];
  491.             edt_buf[0] = 0;
  492.         }
  493.         switch (curwp -> w_fmt_ptr -> r_size)
  494.         {
  495.         case BYTES:
  496.             sprintf (text_buf, MSG_03u, (int) (edt_buf[0] & 0xff));
  497.             if (!dec_chr_ok (text_buf, max_dec_8, c, u_offs))
  498.             {
  499.                 bad_key (k);
  500.                 return (TRUE);  /* TRUE so that mask will be same len */
  501.             }
  502.             sscanf (text_buf, MSG_3u, &i);/* convert back to binary */
  503.             l_val = (long) i & 0xff;
  504.             break;
  505.  
  506.         case WORDS:
  507.             l_val = get_int (edt_buf);/* do intel swap */
  508.             sprintf (text_buf, MSG_05u, (int) (l_val & 0xFFFF));
  509.             if (!dec_chr_ok (text_buf, max_dec_16, c, u_offs))
  510.             {
  511.                 bad_key (k);
  512.                 return (TRUE);  /* TRUE so that mask will be same len */
  513.             }
  514.             sscanf (text_buf, MSG_5u, &temp_int);
  515.             /* convert back to binary */
  516.             l_val = get_int ((char *) & temp_int);/* do intel swap */
  517.             break;
  518.  
  519.         case DWORDS:
  520.             l_val = get_long (edt_buf);/* do intel swap */
  521.             sprintf (text_buf, MSG_010lu, l_val);
  522.             if (!dec_chr_ok (text_buf, max_dec_32, c, u_offs))
  523.             {
  524.                 bad_key (k);
  525.                 return (TRUE);  /* TRUE so that mask will be same len */
  526.             }
  527.             sscanf (text_buf, MSG_lu, &l_val);
  528.             /* convert back to binary */
  529.             l_val = get_long ((char *) & l_val);/* do intel swap */
  530.             break;
  531. #if RUNCHK
  532.         default:
  533.             writ_echo (ERR_rnd_2);
  534.             break;
  535. #endif
  536.         }
  537.         DOT_CHAR(curwp) = (char) l_val & 0xff;
  538.         for (i = 1; i < b_per_u; i++)
  539.         {
  540.             l_val >>= 8;
  541.             move_ptr (curwp, 1L, TRUE, FALSE, TRUE);/* step forward one byte */
  542.             DOT_CHAR(curwp) = (char) l_val & 0xff;
  543.         }
  544.  
  545.         /* restore dot position */
  546.         curwp -> w_dotp = l_ptr;
  547.         curwp -> w_doto = d_offs;
  548.         forwchar (0, 1, KRANDOM);/* advance the cursor */
  549.         break;
  550.  
  551. #if RUNCHK
  552.     default:
  553.         writ_echo (ERR_rnd_3);
  554.         break;
  555. #endif
  556.     }
  557.     /* if cursor has wrapped to the next line then previous line
  558.         will not be refreshed with WFEDIT so do a WFHARD */
  559.     if (cur_col > get_curcol(curwp))
  560.         lchange (WFHARD);
  561.     else
  562.         lchange (WFEDIT);
  563.  
  564.     return (TRUE);
  565. }
  566.  
  567. /*
  568. *   Insert one unit of zeros at the current dot position.
  569. */
  570. bool    insertunit (f, n, k)
  571. {
  572.     lchange (WFEDIT);
  573.     linsert ((R_B_PER_U(curwp) * n), 0);
  574.     return (TRUE);
  575. }
  576.  
  577. /* 
  578. *   Increase the size of the buffer if necessary.
  579. *   If dot is at the byte after the last full unit
  580. *   then add enough bytes to the buffer to create 
  581. *   a full unit at the end.
  582. */
  583.  
  584. bool    fill_out ()
  585. {
  586.     long    buf_size, dot_pos, last_unit;
  587.     int     b_per_u;
  588.     char    stat, shift;
  589.     int     insert_val;
  590.  
  591.     buf_size = BUF_SIZE(curwp);
  592.     dot_pos = DOT_POS(curwp);
  593.     b_per_u = R_B_PER_U(curwp);
  594.     shift = curwp -> w_disp_shift;
  595.     stat = TRUE;
  596.     insert_val = 0;
  597.     last_unit = buf_size & ~((long)(b_per_u - 1));
  598.     /* there is an even number of units step back one */
  599.     if (last_unit == buf_size)
  600.         last_unit -= b_per_u;
  601.     last_unit += shift;
  602.  
  603.     /* if dot is one byte past the end of the buffer */
  604.     if (dot_pos > last_unit)
  605.     {
  606.         insert_val = b_per_u;
  607.     }
  608.  
  609.     /* if dot is pointed at the end of the buffer */
  610.     else if (dot_pos == last_unit)
  611.     {
  612.         insert_val = b_per_u - (buf_size - last_unit);
  613.     }
  614.  
  615.     /* if insert is necessary then do it */
  616.     if (insert_val != 0)
  617.     {
  618.         lchange (WFHARD);
  619.         move_ptr (curwp, buf_size, TRUE, FALSE, FALSE); /* move dot to end */
  620.         stat = linsert (insert_val, 0);
  621.         move_ptr (curwp, dot_pos, TRUE, TRUE, FALSE); /* put dot back */
  622.     }
  623.     return (stat);
  624. }
  625.  
  626. /*
  627. *   This checks that an entered character is ok
  628. *   for the position given.
  629. */
  630.  
  631. char    dec_chr_ok (char_buf, max_str, chr, pos)
  632.  
  633. char    chr,
  634. pos,
  635. *char_buf,
  636. *max_str;
  637.  
  638. {
  639.     char    i;
  640.  
  641.     if ((chr < '0') || (chr > '9'))
  642.         return (FALSE);
  643.  
  644.     char_buf[pos] = chr;        /* insert typed char */
  645.  
  646.     /* check if number is too big */
  647.     for (i = 0; max_str[i] != 0; i++)
  648.     {
  649.         if (char_buf[i] < max_str[i])
  650.             break;              /* if char is smaller then must be ok */
  651.  
  652.         if (char_buf[i] > max_str[i])
  653.             return (FALSE);     /* val is too large; ERROR */
  654.     }
  655.     return (TRUE);
  656. }
  657.  
  658. /*
  659. * Set the rest of the variables for the mode change.
  660. */
  661. void    set_mode_vars ()
  662. {
  663.     curwp -> w_disp_shift = 0;  /* shift to 0 when changing mode */
  664.     curwp -> w_unit_offset = 0; /* go to end of unit */
  665.     /* if we are in the middle of a search then use the proper format struc */
  666.     if (read_pat_mode)
  667.         curwp -> w_fmt_ptr = curwp -> w_fmt_ptr -> r_srch_fmt;
  668.  
  669.     wind_on_dot (curwp);
  670.     curwp -> w_flag = WFHARD;
  671.     update ();
  672. }
  673.  
  674. /*
  675. * Change the display mode to ASCII.
  676. * The default binding is META C-A.
  677. */
  678. bool    asciimode ()
  679. {
  680.     curwp -> w_fmt_ptr = &ascii_fmt;
  681.     set_mode_vars ();
  682.     return (TRUE);
  683. }
  684.  
  685. /*
  686. * Change the display mode to EBCDIC.
  687. * The default binding is META C-E.
  688. */
  689. bool    ebcdicmode ()
  690. {
  691.     curwp -> w_fmt_ptr = &ebcdic_fmt;
  692.     set_mode_vars ();
  693.     return (TRUE);
  694. }
  695.  
  696. /*
  697. * Change the display mode to DECIMAL.
  698. * The default binding is META C-D.
  699. */
  700. bool    decimalmode ()
  701. {
  702.     switch (curwp -> w_fmt_ptr -> r_size)
  703.     {
  704.     case BYTES:
  705.         curwp -> w_fmt_ptr = &decimal_8_fmt;
  706.         break;
  707.     case WORDS:
  708.         curwp -> w_fmt_ptr = &decimal_16_fmt;
  709.         break;
  710.  
  711.     case DWORDS:
  712.         curwp -> w_fmt_ptr = &decimal_32_fmt;
  713.         break;
  714. #if RUNCHK
  715.     default:
  716.         writ_echo (ERR_rnd_4);
  717.         break;
  718. #endif
  719.     }
  720.     set_mode_vars ();
  721.     return (TRUE);
  722. }
  723.  
  724. /*
  725. * Change the display mode to HEXADECIMAL.
  726. * The default binding is META C-H.
  727. */
  728. bool    hexmode ()
  729. {
  730.     switch (curwp -> w_fmt_ptr -> r_size)
  731.     {
  732.     case BYTES:
  733.         curwp -> w_fmt_ptr = &hex_8_fmt;
  734.         break;
  735.     case WORDS:
  736.         curwp -> w_fmt_ptr = &hex_16_fmt;
  737.         break;
  738.     case DWORDS:
  739.         curwp -> w_fmt_ptr = &hex_32_fmt;
  740.         break;
  741. #if RUNCHK
  742.     default:
  743.         writ_echo (ERR_rnd_5);
  744.         break;
  745. #endif
  746.     }
  747.     set_mode_vars ();
  748.     return (TRUE);
  749. }
  750.  
  751. /*
  752. * Change the display mode to OCTAL.
  753. * The default binding is META C-O.
  754. */
  755. bool    octalmode ()
  756. {
  757.     switch (curwp -> w_fmt_ptr -> r_size)
  758.     {
  759.     case BYTES:
  760.         curwp -> w_fmt_ptr = &octal_8_fmt;
  761.         break;
  762.  
  763.     case WORDS:
  764.         curwp -> w_fmt_ptr = &octal_16_fmt;
  765.         break;
  766.  
  767.     case DWORDS:
  768.         curwp -> w_fmt_ptr = &octal_32_fmt;
  769.         break;
  770. #if RUNCHK
  771.     default:
  772.         writ_echo (ERR_rnd_6);
  773.         break;
  774. #endif
  775.     }
  776.     set_mode_vars ();
  777.     return (TRUE);
  778. }
  779.  
  780. /*
  781. * Change the display mode to BINARY.
  782. * The default binding is META C-B.
  783. */
  784. bool    binarymode ()
  785. {
  786.     switch (curwp -> w_fmt_ptr -> r_size)
  787.     {
  788.     case BYTES:
  789.         curwp -> w_fmt_ptr = &binary_8_fmt;
  790.         break;
  791.     case WORDS:
  792.         curwp -> w_fmt_ptr = &binary_16_fmt;
  793.         break;
  794.     case DWORDS:
  795.         curwp -> w_fmt_ptr = &binary_32_fmt;
  796.         break;
  797. #if RUNCHK
  798.     default:
  799.         writ_echo (ERR_rnd_7);
  800.         break;
  801. #endif
  802.     }
  803.     set_mode_vars ();
  804.     return (TRUE);
  805. }
  806.  
  807. /*
  808. * Change the display shift.
  809. * Circularly rotate through display shift of 0 through 3.
  810. * This value is used to shift the display by the designated number of bytes.
  811. * This is used to cause WORD and DWORD values to be calculated
  812. * from the correct offset.
  813. */
  814. bool dispshift (f, n, k)
  815. {
  816.     char    mode,
  817.     size;
  818.  
  819.     if (read_pat_mode)
  820.         return (TRUE);  /* no shift is allowed in search mode */
  821.  
  822.  
  823.     mode = curwp -> w_fmt_ptr -> r_type;
  824.     size = curwp -> w_fmt_ptr -> r_size;
  825.  
  826.     if (((mode == HEX) ||
  827.         (mode == DECIMAL) ||
  828.         (mode == BINARY) ||
  829.         (mode == OCTAL)) &&
  830.         (size != BYTES))
  831.     {
  832.         if ((size == WORDS) &&
  833.             (curwp -> w_disp_shift >= 1))
  834.         {                   /* roll over on words */
  835.             curwp -> w_disp_shift = 0;
  836.         }
  837.         else
  838.             if ((size == DWORDS) &&
  839.                 (curwp -> w_disp_shift >= 3))
  840.             {               /* roll over on double words */
  841.                 curwp -> w_disp_shift = 0;
  842.             }
  843.             else
  844.             {
  845.                 curwp -> w_disp_shift++;/* increment shift */
  846.             }
  847.     }
  848.     else
  849.     {
  850.         curwp -> w_disp_shift = 0;/* set to no shift */
  851.     }
  852.     move_ptr (curwp, 0L, TRUE, TRUE, TRUE);
  853.     wind_on_dot (curwp);
  854.     curwp -> w_flag = WFHARD;   /* force full window refresh */
  855.     return (TRUE);
  856. }
  857.  
  858. /*
  859. * Delete forward. This is real
  860. * easy, because the basic delete routine does
  861. * all of the work. Watches for negative arguments,
  862. * and does the right thing. If any argument is
  863. * present, it kills rather than deletes, to prevent
  864. * loss of text if typed with a big argument.
  865. * Normally bound to "C-D".
  866. */
  867. char    forwdel (f, n, k)
  868. {
  869.     char    s;
  870.  
  871.     if (n < 0)
  872.         return (backdel (f, -n, KRANDOM));
  873.  
  874.     s = FALSE;
  875.     if (R_SIZE(curwp) == BYTES)
  876.     {
  877.         if (f != FALSE)
  878.         {
  879.             /* Really a kill.       */
  880.             if ((lastflag & CFKILL) == 0)
  881.                 bclear (&sav_buf);
  882.             thisflag |= CFKILL;
  883.         }
  884.         s = ldelete ((A32)n, f);
  885.         curwp -> w_unit_offset = 0;
  886.     }
  887.     return (s);
  888. }
  889.  
  890.  
  891. /*
  892. * Delete backwards. This is quite easy too,
  893. * because it's all done with other functions. Just
  894. * move the cursor back, and delete forwards.
  895. * Like delete forward, this actually does a kill
  896. * if presented with an argument.
  897. */
  898. char    backdel (f, n, k)
  899. {
  900.  
  901.     int     u_off;
  902.     char    s;
  903.  
  904.     if (n < 0)
  905.         return (forwdel (f, -n, KRANDOM));
  906.  
  907.     s = FALSE;
  908.     if (R_SIZE(curwp) == BYTES)
  909.     {
  910.         u_off = curwp -> w_unit_offset;
  911.         curwp -> w_unit_offset = 0;
  912.         if ((s = backchar (f, n * R_CHR_PER_U(curwp), KRANDOM)) == TRUE)
  913.         {
  914.             s = ldelete ((A32)n, f);
  915.             if (f != FALSE)
  916.             {
  917.                 /* Really a kill.       */
  918.                 if ((lastflag & CFKILL) == 0)
  919.                     bclear (&sav_buf);
  920.                 thisflag |= CFKILL;
  921.             }
  922.         }
  923.         curwp -> w_unit_offset = u_off;
  924.     }
  925.     return (s);
  926. }
  927.  
  928.  
  929. /*
  930. * Change the size of the display unit to BYTE.
  931. * Adjust byte shift to the allowable range.
  932. * Normally bound to "META-1".
  933. */
  934. bool dispsize1 ()
  935. {
  936.     curwp -> w_disp_shift = 0;  /* shift to 0 when changing size */
  937.     curwp -> w_unit_offset = 0; /* go to end of unit */
  938.  
  939.     switch (R_TYPE(curwp))
  940.     {
  941.     case OCTAL:
  942.         curwp -> w_fmt_ptr = &octal_8_fmt;
  943.         break;
  944.  
  945.     case DECIMAL:
  946.         curwp -> w_fmt_ptr = &decimal_8_fmt;
  947.         break;
  948.  
  949.     case HEX:
  950.         curwp -> w_fmt_ptr = &hex_8_fmt;
  951.         break;
  952.  
  953.     case BINARY:
  954.         curwp -> w_fmt_ptr = &binary_8_fmt;
  955.         break;
  956.  
  957.     default:
  958.         return (TRUE);
  959.         break;
  960.     }
  961.  
  962.     /* if we are in the middle of a search then use the proper format struc */
  963.     if (read_pat_mode)
  964.         curwp -> w_fmt_ptr = curwp -> w_fmt_ptr -> r_srch_fmt;
  965.  
  966.     move_ptr (curwp, 0L, TRUE, TRUE, TRUE);
  967.     wind_on_dot (curwp);
  968.     curwp -> w_flag = WFHARD;
  969.     update ();
  970.     return (TRUE);
  971. }
  972.  
  973. /*
  974. * Change the size of the display unit to WORD.
  975. * Adjust byte shift to the allowable range.
  976. * Normally bound to "META-2".
  977. */
  978. bool dispsize2 ()
  979. {
  980.     curwp -> w_disp_shift = 0;  /* shift to 0 when changing size */
  981.     curwp -> w_unit_offset = 0; /* go to end of unit */
  982.  
  983.     switch (R_TYPE(curwp))
  984.     {
  985.     case OCTAL:
  986.         curwp -> w_fmt_ptr = &octal_16_fmt;
  987.         break;
  988.  
  989.     case DECIMAL:
  990.         curwp -> w_fmt_ptr = &decimal_16_fmt;
  991.         break;
  992.  
  993.     case HEX:
  994.         curwp -> w_fmt_ptr = &hex_16_fmt;
  995.         break;
  996.  
  997.     case BINARY:
  998.         curwp -> w_fmt_ptr = &binary_16_fmt;
  999.         break;
  1000.  
  1001.     default:
  1002.         return (TRUE);
  1003.         break;
  1004.     }
  1005.  
  1006.     /* if we are in the middle of a search then use the proper format struc */
  1007.     if (read_pat_mode)
  1008.         curwp -> w_fmt_ptr = curwp -> w_fmt_ptr -> r_srch_fmt;
  1009.  
  1010.     move_ptr (curwp, 0L, TRUE, TRUE, TRUE);
  1011.     wind_on_dot (curwp);
  1012.     curwp -> w_flag = WFHARD;
  1013.     update ();
  1014.     return (TRUE);
  1015. }
  1016.  
  1017. /*
  1018. * Change the size of the display unit to DOUBLE WORD.
  1019. * Adjust byte shift to the allowable range.
  1020. * Normally bound to "META-4".
  1021. */
  1022. bool dispsize4 ()
  1023. {
  1024.     curwp -> w_disp_shift = 0;  /* shift to 0 when changing size */
  1025.     curwp -> w_unit_offset = 0; /* go to end of unit */
  1026.  
  1027.     switch (R_TYPE(curwp))
  1028.     {
  1029.     case OCTAL:
  1030.         curwp -> w_fmt_ptr = &octal_32_fmt;
  1031.         break;
  1032.  
  1033.     case DECIMAL:
  1034.         curwp -> w_fmt_ptr = &decimal_32_fmt;
  1035.         break;
  1036.  
  1037.     case HEX:
  1038.         curwp -> w_fmt_ptr = &hex_32_fmt;
  1039.         break;
  1040.  
  1041.     case BINARY:
  1042.         curwp -> w_fmt_ptr = &binary_32_fmt;
  1043.         break;
  1044.  
  1045.     default:
  1046.         return (TRUE);
  1047.         break;
  1048.     }
  1049.  
  1050.     /* if we are in the middle of a search then use the proper format struc */
  1051.     if (read_pat_mode)
  1052.         curwp -> w_fmt_ptr = curwp -> w_fmt_ptr -> r_srch_fmt;
  1053.  
  1054.     move_ptr (curwp, 0L, TRUE, TRUE, TRUE);
  1055.     wind_on_dot (curwp);
  1056.     curwp -> w_flag = WFHARD;
  1057.     update ();
  1058.     return (TRUE);
  1059. }
  1060.  
  1061. /*
  1062. * Display byte swaped.   This command causes the bytes
  1063. * that are displayed in WORD and DWORD mode to be swaped
  1064. * in the way that the INTEL microprocessors do it.
  1065. */
  1066. bool dispswapbyte (f, n, k)
  1067. {
  1068.     if ((curwp -> w_fmt_ptr -> r_size) == BYTES)
  1069.         return (TRUE);
  1070.  
  1071.     if (curwp -> w_intel_mode)
  1072.         curwp -> w_intel_mode = FALSE;
  1073.     else
  1074.         curwp -> w_intel_mode = TRUE;
  1075.  
  1076.     curwp -> w_flag = WFHARD;
  1077.     update ();
  1078.     return (TRUE);
  1079. }
  1080.  
  1081. /*
  1082. * Yank text back from the kill buffer. This
  1083. * is really easy. All of the work is done by the
  1084. * standard insert routines. All you do is run the loop,
  1085. * and check for errors. 
  1086. * An attempt has been made to fix the cosmetic bug
  1087. * associated with a yank when dot is on the top line of
  1088. * the window (nothing moves, because all of the new
  1089. * text landed off screen).
  1090. */
  1091. bool yank (f, n, k)
  1092. {
  1093.     register D16    c;
  1094.     register A32    i;
  1095.     char        buf[NCOL], buf1[NCOL];
  1096.  
  1097.     if (n < 0)
  1098.         return (FALSE);
  1099.     while (n--)
  1100.     {
  1101.         i = 0;
  1102.         save_buf_home ();
  1103.         while ((c = get_save_char ()) != (D16)-1)
  1104.         {
  1105.             if (linsert (1, c) == FALSE)
  1106.                 return (FALSE);
  1107.             if ((i & 0x2ff) == 0)
  1108.             {
  1109.                 sprintf (buf1, MSG_procing, R_POS_FMT(curwp));
  1110.                 sprintf (buf, buf1, (ulong)i);
  1111.                 writ_echo (buf);
  1112.                 /* check if we should quit */
  1113.                 if (ttkeyready ())
  1114.                 {
  1115.                     wind_on_dot_all();
  1116.                     if (ttgetc () == CTL_G)
  1117.                         return (FALSE);
  1118.                 }
  1119.             }
  1120.             ++i;
  1121.         }
  1122.     }
  1123.     /* update buffer display */
  1124.     if ((blistp -> b_nwnd != 0) &&
  1125.         (blistp -> b_type == BTLIST))
  1126.         listbuffers ();
  1127.  
  1128.     curwp -> w_flag |= WFHARD;
  1129.     return (TRUE);
  1130. }
  1131.  
  1132. /*
  1133. *   Link windows.   pvr
  1134. *   This function toggles the window linking function.
  1135. *   When linking is enabled all windows that look at 
  1136. *   the same buffer will be forced to have the same 
  1137. *   dot position.   Each window is then moved to be
  1138. *   positioned on the dot.   Thus when a user moves
  1139. *   arround a buffer all other views into that buffer 
  1140. *   will follow.
  1141. */
  1142.  
  1143. bool linkwind ()
  1144.  
  1145. {
  1146.     char    buf[NCOL];
  1147.  
  1148.     if (curwp -> w_bufp -> b_flag & BFLINK)
  1149.     {
  1150.         curwp -> w_bufp -> b_flag &= ~(BFLINK & 0xff);
  1151.         sprintf (buf, MSG_lnk, curwp -> w_bufp -> b_bname, MSG_unlink);
  1152.     }
  1153.     else
  1154.     {
  1155.         curwp -> w_bufp -> b_flag |= BFLINK;
  1156.         sprintf (buf, MSG_lnk, curwp -> w_bufp -> b_bname, MSG_link);
  1157.     }
  1158.     writ_echo (buf);
  1159.     return (TRUE);
  1160. }
  1161. /*
  1162. *   Print all bad keys to the screen and beep 
  1163. */
  1164. void    bad_key (key)
  1165. int     key;
  1166. {
  1167.     char    buf[NCOL];
  1168.  
  1169.     ttbeep ();
  1170.     sprintf (buf, MSG_bad_key);
  1171.     keyname (&buf[strlen (buf)], key);
  1172.     sprintf (&buf[strlen (buf)], ", %X", key);
  1173.     writ_echo (buf);
  1174. }
  1175.  
  1176. /*
  1177.  *    Combine sequential bytes from the rest of the windows
  1178.  *    into this window.   This is useful in combining PROM
  1179.  *    image files from odd and even bytes into one file.
  1180.  */
  1181. bool    n_way_combine (f, n, k)
  1182. {
  1183.     WINDOW * dest_wp, *src_wp;
  1184.     BUFFER *src_bp;
  1185.     A32    dotp;
  1186.     D8    byt;
  1187.     int j = 0;
  1188.     char        buf[NCOL], buf1[NCOL];
  1189.  
  1190.     /* save the destination window for later restore */
  1191.     dest_wp = curwp;
  1192.  
  1193.     if ((BUF_SIZE (curwp)) != (A32)0)
  1194.     {
  1195.         writ_echo (MSG_w_not_empty);
  1196.         return(FALSE);
  1197.     }
  1198.     /* Current window must be empty, modifiable and not the only one. */
  1199.     if ((BUF_SIZE (curwp) != 0) ||
  1200.         (curwp -> w_wndp == NULL) ||
  1201.         (curwp -> w_bufp -> b_flag & (BFVIEW | BFSLOCK)))
  1202.     {
  1203.         writ_echo (MSG_w_not_empty);
  1204.         return(FALSE);
  1205.     }
  1206.  
  1207.  
  1208.  
  1209.  
  1210.     for (;;)
  1211.     {
  1212.         /* step to the next window after the destination window */
  1213.         nextwind();
  1214.  
  1215.         /* as I cycle around the windows skip the destination window */
  1216.         if (curwp == dest_wp)
  1217.         {
  1218.             continue;
  1219.         }
  1220.         byt = DOT_CHAR(curwp) & 0xff;
  1221.         dotp = DOT_POS(curwp);   /* get the current dot position */
  1222.         /* move the dot position ahead in current buffer */
  1223.         if (move_ptr (curwp, 1L, TRUE, FALSE, TRUE) == FALSE)
  1224.         {
  1225.             /* did we advance? */
  1226.             if (DOT_POS(curwp) == dotp)
  1227.             {
  1228.                 wind_on_dot_all();
  1229.                 writ_echo (MSG_ok);
  1230.                 return (TRUE);   /* done all that we could */
  1231.             }
  1232.         }
  1233.  
  1234.         src_wp = curwp;
  1235.         src_bp = curwp -> w_bufp;
  1236.         curwp = dest_wp;
  1237.         curbp = dest_wp -> w_bufp;
  1238.         if (linsert (1, byt) == FALSE)
  1239.         {
  1240.             wind_on_dot_all();
  1241.             return (FALSE);    /* insert failed for some reason */
  1242.         }
  1243.         curwp = src_wp;
  1244.         curbp = src_bp;
  1245.         if ((j++ & 0x2ff) == 0)
  1246.         {
  1247.             sprintf (buf1, MSG_procing, R_POS_FMT(curwp));
  1248.             sprintf (buf, buf1, dotp);
  1249.             writ_echo (buf);
  1250.             /* check if we should quit */
  1251.             if (ttkeyready ())
  1252.             {
  1253.                 wind_on_dot_all();
  1254.                 if (ttgetc () == CTL_G)
  1255.                     return (FALSE);
  1256.             }
  1257.         }
  1258.     }
  1259. }
  1260.  
  1261. /*
  1262.  *    Split the current buffer into the rest of the windows.
  1263.  *    This is useful in splitting a binary file into PROM
  1264.  *    image files.
  1265.  */
  1266. bool    n_way_split (f, n, k)
  1267. {
  1268.     WINDOW  *src_wp;
  1269.     A32     b_size;
  1270.     D8    byt;
  1271.     int j = 0;
  1272.     char        buf[NCOL], buf1[NCOL];
  1273.  
  1274.     /* save the source window and buffer for later restore */
  1275.     src_wp = curwp;
  1276.  
  1277.     /* step to the next window after the source window */
  1278.     nextwind();
  1279.  
  1280.     /* check that all the destination windows are empty and modifiable */
  1281.     for (;;)
  1282.     {
  1283.         if ((BUF_SIZE (curwp) != 0) ||
  1284.             (curwp -> w_bufp -> b_flag & (BFVIEW | BFSLOCK)))
  1285.         {
  1286.             writ_echo (MSG_w_not_empty);
  1287.             return(FALSE);
  1288.         }
  1289.  
  1290.         /* force all windows to be refreshed */
  1291.         lchange (WFHARD);
  1292.         /* step to the next window */
  1293.         nextwind();
  1294.         /* stop after one pass around the windows */
  1295.         if (curwp == src_wp)
  1296.             break;
  1297.     }
  1298.  
  1299.     b_size = BUF_SIZE(src_wp);  /* get the buffer size */
  1300.  
  1301.     /* do the split until source is exhausted */
  1302.     for (;;)
  1303.     {
  1304.         /* step to the next window after the source window */
  1305.         nextwind();
  1306.  
  1307.         /* current window cannot be the source */
  1308.         if (curwp == src_wp)
  1309.             continue;
  1310.  
  1311.         byt = DOT_CHAR(src_wp) & 0xff;   /* get the byte to copy */
  1312.  
  1313.         /* are we at the end of the buffer */
  1314.         if (b_size == DOT_POS(src_wp))
  1315.         {
  1316.             wind_on_dot_all();
  1317.             writ_echo (MSG_ok);
  1318.             return (TRUE);
  1319.         }
  1320.         if (linsert (1, byt) == FALSE)
  1321.         {
  1322.             wind_on_dot_all();
  1323.             return (FALSE);
  1324.         }
  1325.         if ((j++ & 0x2ff) == 0)
  1326.         {
  1327.             sprintf (buf1, MSG_procing, R_POS_FMT(src_wp));
  1328.             sprintf (buf, buf1, DOT_POS(src_wp));
  1329.             writ_echo (buf);
  1330.             /* check if we should quit */
  1331.             if (ttkeyready ())
  1332.             {
  1333.                 wind_on_dot_all();
  1334.                 if (ttgetc () == CTL_G)
  1335.                     return (FALSE);
  1336.             }
  1337.         }
  1338.         if (move_ptr (src_wp, 1L, TRUE, FALSE, TRUE) == FALSE)
  1339.         {
  1340.             wind_on_dot_all();
  1341.             writ_echo (MSG_ok);
  1342.             return (TRUE);    /* hit the end of the source buffer */
  1343.         }
  1344.     }
  1345. }
  1346.  
  1347. void wind_on_dot_all ()
  1348. {
  1349.     WINDOW  *wp;
  1350.  
  1351.     wp = curwp;
  1352.     do
  1353.     {
  1354.         wind_on_dot (curwp);
  1355.         nextwind();
  1356.     }    while (wp != curwp);
  1357. }
  1358.